SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Variadic function</title>

</head>

Variadic function

</h1>

</header>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">"Varargs" redirects here. For the varargs.h library in C, see <a href="Varargs.h" class="mw-redirect" title="Varargs.h">varargs.h</a>.</div>

In <a href="Mathematics" title="Mathematics">mathematics</a> and in <a href="Computer_programming" title="Computer programming">computer programming</a>, a variadic function is a <a href="Function_(programming)" class="mw-redirect" title="Function (programming)">function</a> of indefinite <a href="Arity" title="Arity">arity</a>, i.e., one which accepts a variable number of <a href="Argument_(computer_science)" class="mw-redirect" title="Argument (computer science)">arguments</a>. Support for variadic functions differs widely among <a href="Programming_language" title="Programming language">programming languages</a>.

The term variadic is a <a href="Neologism" title="Neologism">neologism</a>, dating back to 1936/1937.<a href="#cite_note-1">[1]</a> The term was not widely used until the 1970s.

<div class="mw-heading mw-heading2"><h2 id="Overview">Overview</h2></div>

There are many mathematical and logical operations that come across naturally as variadic functions. For instance, the summing of numbers or the <a href="Concatenation" title="Concatenation">concatenation</a> of strings or other sequences are operations that can be thought of as applicable to any number of operands (even though formally in these cases the <a href="Associative_property" title="Associative property">associative property</a> is applied).

Another operation that has been implemented as a variadic function in many languages is output formatting. The <a href="C_(programming_language)" title="C (programming language)">C</a> function <a href="Printf" title="Printf"><code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">printf</code></a> and the <a href="Common_Lisp" title="Common Lisp">Common Lisp</a> function <a href="Format_(Common_Lisp)" title="Format (Common Lisp)"><code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">format</code></a> are two such examples. Both take one argument that specifies the formatting of the output, and any number of arguments that provide the values to be formatted.

Variadic functions can expose <a href="Type_safety" title="Type safety">type-safety</a> problems in some languages. For instance, C's <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">printf</code>, if used incautiously, can give rise to a class of security holes known as <a href="Format_string_attack" class="mw-redirect" title="Format string attack">format string attacks</a>. The attack is possible because the language support for variadic functions is not type-safe: it permits the function to attempt to pop more arguments off the <a href="Stack_(abstract_data_type)#Hardware_stacks" title="Stack (abstract data type)">stack</a> than were placed there, corrupting the stack and leading to unexpected behavior. As a consequence of this, the <a href="CERT_Coordination_Center" title="CERT Coordination Center">CERT Coordination Center</a> considers variadic functions in C to be a high-severity security risk.<a href="#cite_note-2">[2]</a>

In <a href="Functional_programming" title="Functional programming">functional programming</a> languages, variadics can be considered complementary to the <a href="Apply" title="Apply">apply</a> function, which takes a function and a list/sequence/array as arguments, and calls the function with the arguments supplied in that list, thus passing a variable number of arguments to the function. In the functional language <a href="Haskell" title="Haskell">Haskell</a>, variadic functions can be implemented by returning a value of a <a href="Type_class" title="Type class">type class</a> <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">T</code>; if instances of <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">T</code> are a final return value <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">r</code> and a function <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">(T t) => x -> t</code>, this allows for any number of additional arguments <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">x</code>.

A related subject in <a href="Term_rewriting" class="mw-redirect" title="Term rewriting">term rewriting</a> research is called hedges, or hedge variables.<a href="#cite_note-3">[3]</a> Unlike variadics, which are functions with arguments, hedges are sequences of arguments themselves. They also can have constraints ('take no more than 4 arguments', for example) to the point where they are not variable-length (such as 'take exactly 4 arguments') - thus calling them variadics can be misleading. However they are referring to the same phenomenon, and sometimes the phrasing is mixed, resulting in names such as variadic variable (synonymous to hedge). Note the double meaning of the word variable and the difference between arguments and variables in functional programming and term rewriting. For example, a term (function) can have three variables, one of them a hedge, thus allowing the term to take three or more arguments (or two or more if the hedge is allowed to be empty).

<div class="mw-heading mw-heading2"><h2 id="Examples">Examples</h2></div>

To portably implement variadic functions in the <a href="C_(programming_language)" title="C (programming language)">C language</a>, the standard <a href="Stdarg.h" title="Stdarg.h"><code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">stdarg.h</code></a> header file is used. The older <a href="Varargs.h" class="mw-redirect" title="Varargs.h"><code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">varargs.h</code></a> header has been <a href="Deprecation" title="Deprecation">deprecated</a> in favor of <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">stdarg.h</code>. In C++, the header file <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">cstdarg</code> is used.<a href="#cite_note-4">[4]</a>

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>#include <stdarg.h>

#include <stdio.h>

double average(int count, ...) {

va_list ap;

int j;

double sum = 0;

va_start(ap, count); /* Before C23: Requires the last fixed parameter (to get the address) */

for (j = 0; j < count; j++) {

sum += va_arg(ap, int); /* Increments ap to the next argument. */

}

va_end(ap);

return sum / count;

}

int main(int argc, char const *argv[]) {

printf("%f\n", average(3, 1, 2, 3));

return 0;

}

</pre></div>

This will compute the average of an arbitrary number of arguments. Note that the function does not know the number of arguments or their types. The above function expects that the types will be <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">int</code>, and that the number of arguments is passed in the first argument (this is a frequent usage but by no means enforced by the language or compiler). In some other cases, for example <a href="Printf" title="Printf">printf</a>, the number and types of arguments are figured out from a format string. In both cases, this depends on the programmer to supply the correct information. (Alternatively, a <a href="Sentinel_value" title="Sentinel value">sentinel value</a> like <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">NULL</code> or <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">nullptr</code> may be used to indicate the end of the parameter list.) If fewer arguments are passed in than the function believes, or the types of arguments are incorrect, this could cause it to read into invalid areas of memory and can lead to vulnerabilities like the <a href="Format_string_attack" class="mw-redirect" title="Format string attack">format string attack</a>. Depending on the system, even using <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">NULL</code> as a sentinel may encounter such problems; <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">nullptr</code> or a dedicated null pointer of the correct target type may be used to avoid them.

<code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">stdarg.h</code> declares a type, <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code>, and defines four macros: <a href="Va_start" class="mw-redirect" title="Va start"><code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_start</code></a>, <a href="Va_arg" class="mw-redirect" title="Va arg"><code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_arg</code></a>, <a href="Va_copy" class="mw-redirect" title="Va copy"><code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_copy</code></a>, and <a href="Va_end" class="mw-redirect" title="Va end"><code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_end</code></a>. Each invocation of <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_start</code> and <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_copy</code> must be matched by a corresponding invocation of <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_end</code>. When working with variable arguments, a function normally declares a variable of type <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code> (<code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">ap</code> in the example) that will be manipulated by the macros.

<ol><li><code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_start</code> takes two arguments, a <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code> object and a reference to the function's last parameter (the one before the ellipsis; the macro uses this to get its bearings). In <a href="C23_(C_standard_revision)" title="C23 (C standard revision)">C23</a>, the second argument will no longer be required and variadic functions will no longer need a named parameter before the ellipsis.<a href="#cite_note-KandR-6">[note 1]</a><a href="#cite_note-N2975-7">[6]</a> It initialises the <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code> object for use by <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_arg</code> or <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_copy</code>. The compiler will normally issue a warning if the reference is incorrect (e.g. a reference to a different parameter than the last one, or a reference to a wholly different object), but will not prevent compilation from completing normally.</li>

<li><code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_arg</code> takes two arguments, a <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code> object (previously initialised) and a type descriptor. It expands to the next variable argument, and has the specified type. Successive invocations of <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_arg</code> allow processing each of the variable arguments in turn. Unspecified behavior occurs if the type is incorrect or there is no next variable argument.</li>

<li><code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_end</code> takes one argument, a <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code> object. It serves to clean up. If one wanted to, for instance, scan the variable arguments more than once, the programmer would re-initialise your <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code> object by invoking <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_end</code> and then <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_start</code> again on it.</li>

<li><code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_copy</code> takes two arguments, both of them <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code> objects. It clones the second (which must have been initialised) into the first. Going back to the "scan the variable arguments more than once" example, this could be achieved by invoking <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_start</code> on a first <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code>, then using <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_copy</code> to clone it into a second <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code>. After scanning the variable arguments a first time with <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_arg</code> and the first <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code> (disposing of it with <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_end</code>), the programmer could scan the variable arguments a second time with <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_arg</code> and the second <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code>. <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_end</code> needs to also be called on the cloned <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">va_list</code> before the containing function returns.</li></ol>

<a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a> describes variadic functions using the <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">params</code> keyword. A type must be provided for the arguments, although <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">object[]</code> can be used as a catch-all. At the calling site, you can either list the arguments one by one, or hand over a pre-existing array having the required element type. Using the variadic form is <a href="Syntactic_sugar" title="Syntactic sugar">Syntactic sugar</a> for the latter.

<div class="mw-highlight mw-highlight-lang-c# mw-content-ltr" dir="ltr"><pre>using System;

class Program

{

static int Foo(int a, int b, params int[] args)

{

// Return the sum of the integers in args, ignoring a and b.

int sum = 0;

foreach (int i in args)

sum += i;

return sum;

}

static void Main(string[] args)

{

Console.WriteLine(Foo(1, 2)); // 0

Console.WriteLine(Foo(1, 2, 3, 10, 20)); // 33

int[] manyValues = new int[] { 13, 14, 15 };

Console.WriteLine(Foo(1, 2, manyValues)); // 42

}

}

</pre></div>

The basic variadic facility in C++ is largely identical to that in C. The only difference is in the syntax, where the comma before the ellipsis can be omitted. C++ allows variadic functions without <a href="Named_parameter" title="Named parameter">named parameters</a> but provides no way to access those arguments since <code>va_start</code> requires the name of the last fixed argument of the function.

<div class="mw-highlight mw-highlight-lang-c++ mw-content-ltr" dir="ltr"><pre>#include <iostream>

#include <cstdarg>

void simple_printf(const char* fmt...) // C-style "const char* fmt, ..." is also valid

{

va_list args;

va_start(args, fmt);

while (*fmt != '\0') {

if (*fmt == 'd') {

int i = va_arg(args, int);

} else if (*fmt == 'c') {

// note automatic conversion to integral type

int c = va_arg(args, int);

std::cout << static_cast<char>(c) << '\n';

} else if (*fmt == 'f') {

double d = va_arg(args, double);

}

++fmt;

}

va_end(args);

}

int main()

{

simple_printf("dcff", 3, 'a', 1.999, 42.5);

}

</pre></div>

<a href="Variadic_templates" class="mw-redirect" title="Variadic templates">Variadic templates</a> (parameter pack) can also be used in C++ with language built-in <a href="Fold_(higher-order_function)" title="Fold (higher-order function)">fold expressions</a>.

<div class="mw-highlight mw-highlight-lang-c++ mw-content-ltr" dir="ltr"><pre>#include <iostream>

template <typename... Ts>

void foo_print(Ts... args)

{

((std::cout << args << ' '), ...);

}

int main()

{

foo_print(1, 3.14f); // 1 3.14

foo_print("Foo", 'b', true, nullptr); // Foo b true nullptr

}

</pre></div>

The <a href="CERT_Coding_Standards" title="CERT Coding Standards">CERT Coding Standards</a> for C++ strongly prefers the use of <a href="Variadic_templates" class="mw-redirect" title="Variadic templates">variadic templates</a> (parameter pack) in C++ over the C-style variadic function due to a lower risk of misuse.<a href="#cite_note-8">[7]</a>

<div class="mw-heading mw-heading3"><h3 id="In_Fortran">In Fortran</h3></div>

Since the Fortran 90 revision, <a href="Fortran" title="Fortran">Fortran</a> functions or subroutines can accept optional arguments:<a href="#cite_note-9">[8]</a> the argument list is still fixed, but the ones that have the <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">optional</code> attribute can be omitted in the function/subroutine call. The intrinsic function <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">present()</code> can be used to detect the presence of an optional argument. The optional arguments can appear anywhere in the argument list.

<div class="mw-highlight mw-highlight-lang-fortran mw-content-ltr" dir="ltr"><pre>program test

implicit none

real :: x

!> all arguments are passed:

call foo( 1, 2, 3.0, 4, x )

!< outputs 1 \ 2 \ 3.0 \ 4 \ 6.0 (the "\" denotes a newline)

!> the last 2 arguments are omitted:

!< outputs 1 \ 2 \ 3.0

!> the 2nd and 4th arguments are omitted: the arguments that are positioned after

!> an omitted argument must be passed with a keyword:

call foo( 1, c=3.0, e=x )

!< outputs 1 \ 3.0 \ 6.0

!> alternatively, the Fortran 2023 revision has introduced the .NIL. pseudo constant

!> to denote an omitted argument

call foo( 1, .NIL., 3.0, .NIL., x )

!< outputs 1 \ 3.0 \ 6.0

contains

!> the subroutine foo() has 2 mandatory and 3 optional arguments

subroutine foo( a, b, c, d, e )

integer, intent(in) :: a

integer, intent(in), optional :: b

real, intent(in) :: c

integer, intent(in), optional :: d

real, intent(out), optional :: e

print*, a

if (present(b)) print*, b

print*, c

if (present(d)) print*, d

e = 2*c

print*, c

end if

end subroutine

end program

</pre></div>

Output:

<pre>The sum of [1 2] is 3

The sum of [1 2 3] is 6

The sum of [1 2 3 4] is 10

</pre>

Variadic functions in <a href="Go_(programming_language)" title="Go (programming language)">Go</a> can be called with any number of trailing arguments.<a href="#cite_note-10">[9]</a> <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">fmt.Println</code> is a common variadic function; it uses an empty interface as a catch-all type.

<div class="mw-highlight mw-highlight-lang-go mw-content-ltr" dir="ltr"><pre>package main

import "fmt"

// This variadic function takes an arbitrary number of ints as arguments.

func sum(nums ...int) {

fmt.Print("The sum of ", nums) // Also a variadic function.

total := 0

for _, num := range nums {

total += num

}

fmt.Println(" is", total) // Also a variadic function.

}

func main() {

// Variadic functions can be called in the usual way with individual

// arguments.

sum(1, 2) // "The sum of [1 2] is 3"

sum(1, 2, 3) // "The sum of [1 2 3] is 6"

// If you already have multiple args in a slice, apply them to a variadic

// function using func(slice...) like this.

nums := []int{1, 2, 3, 4}

sum(nums...) // "The sum of [1 2 3 4] is 10"

}

</pre></div>

Output:

<pre>The sum of [1 2] is 3

The sum of [1 2 3] is 6

The sum of [1 2 3 4] is 10

</pre>

As with C#, the <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">Object</code> type in <a href="Java_(programming_language)" title="Java (programming language)">Java</a> is available as a catch-all.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public class Program {

// Variadic methods store any additional arguments they receive in an array.

// Consequentially, `printArgs` is actually a method with one parameter: a

// variable-length array of `String`s.

private static void printArgs(String... strings) {

for (String string : strings) {

System.out.println(string);

}

public static void main(String[] args) {

printArgs("hello"); // short for printArgs(["hello"])

printArgs("hello", "world"); // short for printArgs(["hello", "world"])

}

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="In_JavaScript">In JavaScript</h3></div>

<a href="JavaScript" title="JavaScript">JavaScript</a> does not care about types of variadic arguments.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>function sum(...numbers) {

return numbers.reduce((a, b) => a + b, 0);

}

console.log(sum(1, 2, 3)); // 6

console.log(sum(3, 2)); // 5

console.log(sum()); // 0

</pre></div>

It's also possible to create a variadic function using the arguments object, although it is only usable with functions created with the <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">function</code> keyword.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>function sum() {

return Array.prototype.reduce.call(arguments, (a, b) => a + b, 0);

}

console.log(sum(3, 2)); // 5

</pre></div>

<a href="Lua_(programming_language)" class="mw-redirect" title="Lua (programming language)">Lua</a> functions may pass varargs to other functions the same way as other values using the <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">return</code> keyword. tables can be passed into variadic functions by using, in Lua version 5.2 or higher<a href="#cite_note-11">[10]</a> <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">table.unpack</code>, or Lua 5.1 or lower<a href="#cite_note-12">[11]</a> <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">unpack</code>. Varargs can be used as a table by constructing a table with the vararg as a value.<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre>function sum(...) --... designates varargs

local sum=0

for _,v in pairs({...}) do --creating a table with a varargs is the same as creating one with standard values

sum=sum+v

end

return sum

end

values={1,2,3,4}

sum(5,table.unpack(values)) --returns 15. table.unpack should go after any other arguments, otherwise not all values will be passed into the function.

function add5(...)

return ...+5 --this is incorrect usage of varargs, and will only return the first value provided

end

entries={}

function process_entries()

local processed={}

for i,v in pairs(entries) do

processed[i]=v --placeholder processing code

end

return table.unpack(processed) --returns all entries in a way that can be used as a vararg

end

print(process_entries()) --the print function takes all varargs and writes them to stdout separated by newlines

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="In_Pascal">In Pascal</h3></div>

<a href="Pascal_(programming_language)" title="Pascal (programming language)">Pascal</a> is standardized by <a href="International_Organization_for_Standardization" title="International Organization for Standardization">ISO</a> standards 7185 (“Standard Pascal”) and 10206 (“Extended Pascal”).

Neither standardized form of Pascal supports variadic routines, except for certain <a href="Intrinsic_function" title="Intrinsic function">built-in routines</a> (<code class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" style="" dir="ltr">read</code>/<code class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" style="" dir="ltr">readLn</code> and <code class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" style="" dir="ltr">write</code>/<code class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" style="" dir="ltr">writeLn</code>, and additionally in <abbr title="Extended Pascal">EP</abbr> <code class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" style="" dir="ltr">readStr</code>/<code class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" style="" dir="ltr">writeStr</code>).

Nonetheless, dialects of Pascal implement mechanisms resembling variadic routines.

<a href="Delphi_(programming_language)" class="mw-redirect" title="Delphi (programming language)">Delphi</a> defines an <code class="mw-highlight mw-highlight-lang-delphi mw-content-ltr" style="" dir="ltr">array of const</code> data type that may be associated with the last <a href="Formal_parameter" class="mw-redirect" title="Formal parameter">formal parameter</a>.

Within the routine definition the <code class="mw-highlight mw-highlight-lang-delphi mw-content-ltr" style="" dir="ltr">array of const</code> is an <code class="mw-highlight mw-highlight-lang-delphi mw-content-ltr" style="" dir="ltr">array of TVarRec</code>, an <a href="Array_(data_type)" title="Array (data type)">array</a> of <a href="Variant_record" class="mw-redirect" title="Variant record">variant records</a>.<a href="#cite_note-delphi-13">[12]</a>

The <code class="mw-highlight mw-highlight-lang-delphi mw-content-ltr" style="" dir="ltr">VType</code> member of the aforementioned <code class="mw-highlight mw-highlight-lang-delphi mw-content-ltr" style="" dir="ltr">record</code> data type allows inspection of the argument’s data type and subsequent appropriate handling.

The <a href="Free_Pascal_Compiler" class="mw-redirect" title="Free Pascal Compiler">Free Pascal Compiler</a> supports Delphi’s variadic routines, too.<a href="#cite_note-fpc-14">[13]</a>

This implementation, however, technically requires a single argument, that is an <code class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" style="" dir="ltr">array</code>.

Pascal imposes the restriction that arrays need to be homogenous.

This requirement is circumvented by utilizing a variant record.

The <a href="GNU_Pascal" title="GNU Pascal">GNU Pascal</a> defines a real variadic formal parameter specification using an ellipsis (<code class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" style="" dir="ltr">...</code>), but as of 2022 no portable mechanism to use such has been defined.<a href="#cite_note-gpc-15">[14]</a>

Both GNU Pascal and FreePascal allow externally declared functions to use a variadic formal parameter specification using an ellipsis (<code class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" style="" dir="ltr">...</code>).

<a href="PHP" title="PHP">PHP</a> does not care about types of variadic arguments unless the argument is typed.

<div class="mw-highlight mw-highlight-lang-php mw-content-ltr" dir="ltr"><pre>function sum(...$nums): int

{

return array_sum($nums);

}

echo sum(1, 2, 3); // 6

</pre></div>

And typed variadic arguments:

<div class="mw-highlight mw-highlight-lang-php mw-content-ltr" dir="ltr"><pre>function sum(int ...$nums): int

{

return array_sum($nums);

}

echo sum(1, 'a', 3); // TypeError: Argument 2 passed to sum() must be of the type int (since PHP 7.3)

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="In_Python">In Python</h3></div>

<a href="Python_(programming_language)" title="Python (programming language)">Python</a> does not care about types of variadic arguments.

<div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre>def foo(a, b, *args):

print(args) # args is a tuple (immutable sequence).

foo(1, 2) # ()

foo(1, 2, 3) # (3,)

</pre></div>

Keyword arguments can be stored in a dictionary, e.g. <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">def bar(*args, **kwargs)</code>.

In <a href="Raku_(programming_language)" title="Raku (programming language)">Raku</a>, the type of parameters that create variadic functions are known as slurpy array parameters and they're classified into three groups:

<div class="mw-heading mw-heading4"><h4 id="Flattened_slurpy">Flattened slurpy</h4></div>

These parameters are declared with a single asterisk (<code>*</code>) and they flatten arguments by dissolving one or more layers of elements that can be iterated over (i.e, <a rel="nofollow" class="external text" href="https://docs.perl6.org/type/Iterable">Iterables</a>).

<div class="mw-highlight mw-highlight-lang-perl6 mw-content-ltr" dir="ltr"><pre>sub foo($a, $b, *@args) {

say @args.perl;

}

foo(1, 2) # []

foo(1, 2, 3) # [3]

foo(1, 2, 3, "hello") # [3 "hello"]

foo(1, 2, 3, [4, 5], [6]); # [3, 4, 5, 6]

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Unflattened_slurpy">Unflattened slurpy</h4></div>

These parameters are declared with two asterisks (<code>**</code>) and they do not flatten any iterable arguments within the list, but keep the arguments more or less as-is:

<div class="mw-highlight mw-highlight-lang-perl6 mw-content-ltr" dir="ltr"><pre>sub bar($a, $b, **@args) {

say @args.perl;

}

bar(1, 2); # []

bar(1, 2, 3); # [3]

bar(1, 2, 3, "hello"); # [3 "hello"]

bar(1, 2, 3, [4, 5], [6]); # [3, [4, 5], [6]]

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Contextual_slurpy">Contextual slurpy</h4></div>

These parameters are declared with a plus (<code>+</code>) sign and they apply the "<a rel="nofollow" class="external text" href="https://docs.perl6.org/language/functions#Slurpy_conventions">single argument rule</a>", which decides how to handle the slurpy argument based upon context. Simply put, if only a single argument is passed and that argument is iterable, that argument is used to fill the slurpy parameter array. In any other case, <code>+@</code> works like <code>**@</code> (i.e., unflattened slurpy).

<div class="mw-highlight mw-highlight-lang-perl6 mw-content-ltr" dir="ltr"><pre>sub zaz($a, $b, +@args) {

say @args.perl;

}

zaz(1, 2); # []

zaz(1, 2, 3); # [3]

zaz(1, 2, 3, "hello"); # [3 "hello"]

zaz(1, 2, [4, 5]); # [4, 5], single argument fills up array

zaz(1, 2, 3, [4, 5]); # [3, [4, 5]], behaving as **@

zaz(1, 2, 3, [4, 5], [6]); # [3, [4, 5], [6]], behaving as **@

</pre></div>

<a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a> does not care about types of variadic arguments.

<div class="mw-highlight mw-highlight-lang-ruby mw-content-ltr" dir="ltr"><pre>def foo(*args)

print args

end

foo(1)

# prints `[1]=> nil`

foo(1, 2)

# prints `[1, 2]=> nil`

</pre></div>

<a href="Rust_(programming_language)" title="Rust (programming language)">Rust</a> does not support variadic arguments in functions. Instead, it uses <a href="Macro_(computer_science)" title="Macro (computer science)">macros</a>.<a href="#cite_note-16">[15]</a>

<div class="mw-highlight mw-highlight-lang-rust mw-content-ltr" dir="ltr"><pre>macro_rules! calculate {

// The pattern for a single `eval`

{

let val: usize = $e; // Force types to be integers

println!("{} = {}", stringify!{$e}, val);

}

}};

// Decompose multiple `eval`s recursively

(eval $e:expr, $(eval $es:expr),+) => {{

calculate! { eval $e }

calculate! { $(eval $es),+ }

}};

}

fn main() {

eval 1 + 2,

eval 3 + 4,

eval (2 * 3) + 1

}

}

</pre></div>

Rust is able to interact with C's variadic system via a <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">c_variadic</code> feature switch. As with other C interfaces, the system is considered <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">unsafe</code> to Rust.<a href="#cite_note-17">[16]</a>

<div class="mw-heading mw-heading3"><h3 id="In_Scala">In Scala</h3></div>

<div class="mw-highlight mw-highlight-lang-scala mw-content-ltr" dir="ltr"><pre>object Program {

// Variadic methods store any additional arguments they receive in an array.

// Consequentially, `printArgs` is actually a method with one parameter: a

// variable-length array of `String`s.

private def printArgs(strings: String*): Unit = {

strings.foreach(println)

}

def main(args: Array[String]): Unit = {

}

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="In_Swift">In Swift</h3></div>

<a href="Swift_(programming_language)" title="Swift (programming language)">Swift</a> cares about the type of variadic arguments, but the catch-all <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">Any</code> type is available.

<div class="mw-highlight mw-highlight-lang-swift mw-content-ltr" dir="ltr"><pre>func greet(timeOfTheDay: String, names: String...) {

// here, names is [String]

print("Looks like we have \(names.count) people")

for name in names {

print("Hello \(name), good \(timeOfTheDay)")

}

}

greet(timeOfTheDay: "morning", names: "Joseph", "Clara", "William", "Maria")

// Output:

// Looks like we have 4 people

// Hello Joseph, good morning

// Hello Clara, good morning

// Hello William, good morning

// Hello Maria, good morning

</pre></div>

A <a href="Tcl" title="Tcl">Tcl</a> procedure or lambda is variadic when its last argument is <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">args</code>: this will contain a list (possibly empty) of all the remaining arguments. This pattern is common in many other procedure-like methods.<a href="#cite_note-18">[17]</a><a href="#cite_note-19">[18]</a>

<div class="mw-highlight mw-highlight-lang-tcl mw-content-ltr" dir="ltr"><pre>proc greet {timeOfTheDay args} {

puts "Looks like we have [llength $args] people"

foreach name $args {

puts "Hello $name, good $timeOfTheDay"

}

}

greet "morning" "Joseph" "Clara" "William" "Maria"

# Output:

# Looks like we have 4 people

# Hello Joseph, good morning

# Hello Clara, good morning

# Hello William, good morning

# Hello Maria, good morning

</pre></div>

<ul><li><a href="Java_syntax#Varargs" title="Java syntax">Varargs in Java programming language</a></li>

<li><a href="Variadic_macro" class="mw-redirect" title="Variadic macro">Variadic macro</a> (C programming language)</li>

<li><a href="Variadic_template" title="Variadic template">Variadic template</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="Notes">Notes</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

<li id="cite_note-KandR-6"><a href="#cite_ref-KandR_6-0">^</a> Making the named parameter optional was needed since there was no way to specify a function taking an unspecified number of arguments in C23 after the removal of K&R style function definitions. Since C++ was already using this syntax for the same purpose, this change was also a way to increase compatibility between the languages.<a href="#cite_note-5">[5]</a>

</li>

</ol></div></div>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

<li id="cite_note-1"><a href="#cite_ref-1">^</a> Henry S. Leonard and H. N. Goodman, A calculus of individuals. Abstract of a talk given at the Second Meeting of the Association for Symbolic Logic, held in Cambridge MA on December 28–30, 1936, <a rel="nofollow" class="external autonumber" href="https://www.jstor.org/stable/2268861">[1]</a>, Journal of Symbolic Logic 2(1) 1937, 63.

</li>

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite id="CITEREFKlemens2014" class="citation book cs1">Klemens, Ben (2014). 21st Century C: C Tips from the New School. O'Reilly Media, Inc. p. 224. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-1491904442</bdi>.</cite>

</li>

<li id="cite_note-3"><a href="#cite_ref-3">^</a> <a rel="nofollow" class="external text" href="https://arxiv.org/abs/1503.00336">CLP (H): Constraint Logic Programming for Hedges</a>

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20121031160547/http://www.cplusplus.com/reference/clibrary/cstdarg/">"<cstdarg> (stdarg.h) - C++ Reference"</a>. www.cplusplus.com. Archived from <a rel="nofollow" class="external text" href="http://www.cplusplus.com/reference/clibrary/cstdarg/">the original</a> on 2012-10-31. Retrieved 2007-10-02.</cite>

</li>

<li id="cite_note-5"><a href="#cite_ref-5">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://thephd.dev/c23-is-coming-here-is-what-is-on-the-menu#n2975---relax-requirements-for-variadic-parameter-lists">"C23 is Finished: Here is What is on the Menu §N2975 - Relax requirements for variadic parameter lists"</a>. 31 July 2022.</cite>

</li>

<li id="cite_note-N2975-7"><a href="#cite_ref-N2975_7-0">^</a> <cite id="CITEREFGildingMeneide2022" class="citation web cs1">Gilding, Alex; Meneide, JeanHeyd (2022-04-15). <a rel="nofollow" class="external text" href="https://open-std.org/JTC1/SC22/WG14/www/docs/n2975.pdf">"WG14-N2975 : Relax requirements for variadic parameter lists, v3"</a> (PDF).</cite>

</li>

<li id="cite_note-8"><a href="#cite_ref-8">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://wiki.sei.cmu.edu/confluence/display/cplusplus/DCL50-CPP">"DCL50-CPP. Do not define a C-style variadic function"</a>.</cite>

</li>

<li id="cite_note-9"><a href="#cite_ref-9">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.intel.com/content/www/us/en/docs/fortran-compiler/developer-guide-reference/2023-0/optional-arguments.html">"Optional Arguments"</a>. Intel. Retrieved 2025-03-18.</cite>

</li>

<li id="cite_note-10"><a href="#cite_ref-10">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://gobyexample.com/variadic-functions">"Go by Example: Variadic Functions"</a>.</cite>

</li>

<li id="cite_note-11"><a href="#cite_ref-11">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.lua.org/manual/5.2/manual.html#pdf-table.unpack">"Lua 5.2 Reference Manual"</a>. www.lua.org. Retrieved 2023-02-05.</cite>

</li>

<li id="cite_note-12"><a href="#cite_ref-12">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.lua.org/manual/5.1/manual.html#pdf-unpack">"Lua 5.1 Reference Manual"</a>. www.lua.org. Retrieved 2023-02-05.</cite>

</li>

<li id="cite_note-delphi-13"><a href="#cite_ref-delphi_13-0">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docwiki.embarcadero.com/RADStudio/Alexandria/en/Parameters_(Delphi)#Variant_Open_Array_Parameters">"Parameters (Delphi)"</a>. Retrieved 2023-08-28.</cite>

</li>

<li id="cite_note-fpc-14"><a href="#cite_ref-fpc_14-0">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.freepascal.org/docs-html/3.2.0/ref/refsu68.html">"Free Pascal - Reference guide"</a>. Retrieved 2023-08-28.</cite>

</li>

<li id="cite_note-gpc-15"><a href="#cite_ref-gpc_15-0">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.gnu-pascal.de/gpc/Special-Parameters.html">"The GNU Pascal Manual"</a>. Retrieved 2023-08-28.</cite>

</li>

<li id="cite_note-16"><a href="#cite_ref-16">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://doc.rust-lang.org/rust-by-example/macros/variadics.html">"Variadics"</a>. Rust By Example.</cite>

</li>

<li id="cite_note-17"><a href="#cite_ref-17">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://rust-lang.github.io/rfcs/2137-variadic.html">"2137-variadic"</a>. The Rust RFC Book.</cite>

</li>

<li id="cite_note-18"><a href="#cite_ref-18">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.tcl.tk/man/tcl/TclCmd/proc.html">"proc manual page"</a>. Tcl/Tk Documentation.</cite>

</li>

<li id="cite_note-19"><a href="#cite_ref-19">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://wiki.tcl-lang.org/page/args">"args"</a>. Tcler's Wiki.</cite>

</li>

</ol></div></div>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

<ul><li><a rel="nofollow" class="external text" href="http://rosettacode.org/wiki/Variadic_function">Variadic function</a>. <a href="Rosetta_Code" title="Rosetta Code">Rosetta Code</a> task showing the implementation of variadic functions in over 120 programming languages.</li>

<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20070927215504/http://www.codeproject.com/cpp/argfunctions.asp?df=100&forumid=15556&exp=0&select=503481">Variable Argument Functions</a> — A tutorial on Variable Argument Functions for C++</li>

<li><a rel="nofollow" class="external text" href="https://www.gnu.org/software/hello/manual/libc/Variadic-Functions.html">GNU libc manual</a></li></ul></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-07-25" href="https://en.wikipedia.org/wiki/?title=Variadic_function&oldid=1302442431">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>